A computer graphics workstation typically displays images on a raster scan cathode ray tube (CRT). These images are generated by an application program running on a data processor associated with the workstation. Such an image is typically represented by data values corresponding to the intensity or color of each elemental image area, called pixels. To cause the image to appear on the CRT, the pixel data values are first written into a frame buffer memory arranged as a two-dimensional array. The frame buffer memory is then repetitively and sequentially scanned by a refresh circuit so that the pixel data words are read out in synchronism with the CRT's horizontal and vertical refresh rate. The pixel data words are then fed to a digital-to-analog converter (DAC) and finally, in analog form, to the CRT's intensity control.
Since color CRTs have an intensity control for each of their blue, green, and red electron guns, pixel data words for such systems must actually include three data values, corresponding to the desired intensity value for each gun. A DAC must also normally be associated for each gun. The available number of colors thus depends on the range of allowable intensity levels, or number of bits per pixel data word. At present it is generally agreed that a twenty-four bit pixel data word having eight bits for each of the blue, green, and red intensity values provides a pleasing enough range.
Despite the ever-decreasing price of semiconductor memory, frame buffer memory is still relatively expensive, enough so that a workstation which stores the desired twenty-four bit pixel data words can become quite costly, especially if the CRT is to have spatial resolution on the order of a color television. Additionally, most applications do not require the use of all 2.sup.24 possible colors simultaneously. In many instances, then, the pixel data words are not directly fed to the DACs, but rather are used as addresses (i.e., an index) into a second memory called a color lookup table. The data output from the color table is then used to control the DACs. Usually the color table memory words are fairly long, twenty-four bits in the example being discussed, with the color tables' address space being fairly small, say 256 words. This allows each pixel data word in the frame buffer to be only eight bits wide, and yet the desired selection range of 2.sup.24 output colors is achieved. The price paid for this is that only 256 of the 2.sup.24 colors can be displayed simultaneously.
Even when a full twenty-four bit frame buffer (also referred to as a twenty-four plane frame buffer) is affordable, there are applications in which it is desirable to use something other than a one-to-one linear correspondence between pixel data words and the intensity inputs to the CRT. In these instances too, a color table memory can be indispensable.
The application program running on the associated data processor is normally responsible for originating the data in the color table memory. Unfortunately, the color table must be capable of being read out in a very short time, since a color table lookup operation is necessary for each pixel on each display cycle. For example, the color table read access time must normally be 25 nanoseconds or less for a 1000.times.1000 pixel image scanned at the usual 60 hertz frame rate. Effective use of the available color table memory is thus one key to maximizing graphics system performance.
While the foregoing arrangement is sufficient for its intended purpose, certain shortcomings become apparent as advances are made in the architecture of computer workstations. To being with, it is now common for workstations to use multi-tasking operating systems which allow several application programs to run simultaneously. Each application typically runs in its own dedicated area of the display or "window". It is desirable for a window to look like a complete graphics display to its associated application program. For example, in each application program, one would like to be able to specify a particular set of color table entries. Given the high required throughput rate, however, the color table must often be shared by multiple applications. This is due to the fact that semiconductor memory technology is simply not fast enough to allow re-writing of all entries in the color table in the time it takes for the refresh circuit to move from one window to the next, i.e. from one pixel data word to the next, since windows can be adjacent one another (and can even overlap). For the example discussed, this would require writing 256 entries in the 25 ns available between pixel data word readouts.
One solution to this problem would be to provide a separate hardware color table for each window and selectively enable the proper one as successive windows are scanned. However, this is not a particularly cost effective solution, and also places a hardware limitation on the number of windows displayable simultaneously.
While one normally thinks of an eight bit wide frame buffer as containing a single image with eight bits per pixel, it can also be thought of as containing two images, one with five bits per pixel and one with three bits per pixel, or as many as eight images with one bit per pixel, and so forth. Hence, corresponding bits of the pixel data words in the frame buffer memory have come to be referred to as bit planes, or simply planes, since each can be considered to hold a separate image. Thus in the example being discussed, one speaks of having an eight-plane frame buffer. The contents of the color table can then be written in such a way as to enable only one or more desired images at a time.
For example, consider how a bitonal image, such as a single-color grid, can be selectively displayed over a multiple color image. The multiple color image is written in the lower order planes of the frame buffer, e.g., the lower order seven planes in the exemplary eight plane frame buffer. The grid is written into only the high order plane, with logic ones written in the positions where, when the grid is enabled, the grid color is to show, and logic zeros written where the image is to show. To display the image and grid together, the 256-entry color table is written with the lower 128 entries (the ones addressed by the seven lower order bits when the high order bit is a zero) providing the desired colors for the multiple color image. The upper 128 entries (the ones addressed when the high order bit is a one) are all written with the single grid color. To make the grid "disappear", all that needs to be done is to re-write the upper 128 entries to correspond to the lower 128 entries used for the multiple-color image. To make the grid re-appear, the upper 128 entries can be re-written to all have the single grid color.
This approach to selectively displaying images is often useful in applications such as computer-aided design, where it is necessary for the user to select one particular object out of the many on the screen, or place grids over objects, or to display text data written in one plane together with graphic data written in another plane. A plane which can be selectively enabled in this fashion is referred to as an overlay plane. Efficient support of overlay planes is thus yet another reason for letting each application dictate the color table contents. However, implementing overlays in the manner described is not particularly efficient, since a single overlay plane requires using one-half the entries of the color table. If two overlay planes are needed, three-quarters of the color table are used up, and so forth. One solution to the overlay/color table problem is to have a dedicated overlay register which is enabled by a bit in the pixel data word. However, the overlay register tends to become another resource contended for by several applications at once, and also does not eliminate the problem of having each application program control the way in which the planes of the frame buffer address the entries in the color table.
An even worse situation occurs if an object "pick" or "select" feature is desired. With such a feature, an object or a particular area of the screen is selected for further operations. The selected object or area can be so indicated by making it appear brighter. Thus, twice as many entries must be used in the color table, a dim entry and a bright entry for each color. However, the required number of bit planes in the frame buffer is increased by three, since one bit for each color must be added to indicate when it is to appear bright or dim.
Animation techniques such as double buffering also place a heavy burden on the color table. If the application does not justify the cost of two complete frame buffers, the typical approach to double buffering is to split the frame buffer in half. Thus, with an eight plane frame buffer can be used to provide two four plane frame buffers. However this leaves only four planes in each buffer, each of which can select only one of sixteen possible colors. Thus, all 256 entries in the color table must be used, even though only sixteen colors can actually be displayed simultaneously.
To support such features as overlay planes and double buffering, some systems use a mask register to specify which planes are to be enabled at a given time. The contents of the mask register are logically ANDed with each pixel word to select the desired active planes before passing them to the color table address inputs. It is also sometimes necessary, especially for double buffering, to specify a shift of the masked bits word bits to place them in the proper position. A cross-bar switch can be used which allows to allow routing of any bit plane to any color table address input position. However, cross-bar switches tend to require a large number of control inputs (at least N log N where N is the number of bits in the cross-bar switch), and thus in most instances, it is not possible to design one which is reconfigurable at the pixel data word rate without requiring a large number of control planes. Such a cross-bar switch thus tends to become, in most practical systems, yet another resource which must be shared among applications.
Another problem with supporting windows is the often-executed function of clearing the screen. Since it is desirable for a clear operation to occur as quickly as possible, certain semiconductor memory chips designed for use as frame buffers include a built-in flash clear function. The flash clear function can directly clear many bits of the memory chip in a single write cycle, without having to write to all of the addresses sequentially. However, it is often the case that flash clear cannot be directly used to clear windows, since windows have arbitrary boundaries determined by the application program which do not necessarily align with the memory chip organization. Typically, such chips are arranged so that flash clear can only clear an entire row of pixels, or a group of pixels that is a power of two in length. Thus a flash clear operation performed in one memory chip would possibly clear the area occupied by two or more windows. One way to solve this problem is to use one of the bit planes as a so-called valid plane. Rather than clear all planes, just the valid plane is enabled to be cleared by the application program. The valid plane bit is then logically ANDed with another input which is true only when the frame buffer address is inside the particular window. In this fashion, the window can be quickly cleared, but at the price of a plane. When the frame buffer inside the window is written at a particular position, the valid plane is disabled at that location, and the pixel data is allowed to pass through to the color table. However, the use of valid plane clearing is exacerbated in a multiple window environment, where each window normally wishes to specify its own background color to distinguish it from other windows.